package lip6.ivi;

import java.util.Random;
public class Vector extends java.util.Vector<Double>{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	protected int size;

	public Vector(int size){
		super(size);
		this.size = size();
	}

	public String toString(){
		StringBuffer chaine = new StringBuffer();
		chaine.append("( ");
		for( int i = 0; i < this.size(); i++){
			chaine.append( this.get(i)+ " ");
		}
		chaine.append(")");
		return chaine.toString();
	}

	/* Entrée: vecteur courant. 
	 * Sortie : la valeur maximale d'un vecteur. 
	 */
	public double getMaxValue(){
		double valeurMax = Double.NEGATIVE_INFINITY;
		for (int i = 0; i < this.size(); i ++){
			if (this.get(i) >= valeurMax) {
				valeurMax = this.get(i);
			}
		}
		return valeurMax;
	}
	public void init(int size){
		for (int i = 0; i < size; i ++) {
			this.add(i, 0.0);
		}
	}

	public Vector transforme(int [] table ){
		Vector v = new Vector(table.length);
		for (int i = 0; i < table.length; i ++) {
			v.add(i, (double) table[i]);
		}
		return v;
	}
	/*
	 * Entrï¿½e : le vecteur courant
	 * Sortie : un entier, lindice de l'ï¿½lï¿½ments maximum du vecteur
	 */
	public int getItemMaxValue(){
		int item = -1;
		double temp = -20;
		int itemTemp = 0;
		float rand = (float) Math.random();
		for (int i = 0; i < this.size(); i ++) {
			if (this.elementAt(i) >= temp) {
				item = i;
				temp = this.elementAt(i);
				if (this.elementAt(item) == this.elementAt(itemTemp)) {
					if (rand <= 0.01) {  
						item = itemTemp;
					}
				} else {
					itemTemp = item;
				}
			}
		}
		return item;
	}
	/*Entr�e : le vecteur courant 
	 * Sortie : un vecteur qui contient les m�mes �l�ments que le vecteur d'entr�e.
	 */
	public Vector clone(){
		Vector v = new Vector(this.size());
		for (int i = 0; i < this.size(); i ++){
			v.add(i, this.get(i));
		}
		return v;
	}

	 /*Entr�e : le vecteur courant
	 * Sortie : le vecteur courant o� chaque �l�ment est le somme cumul�e des �l�ments qui le succ�de.
	 * exemple entr�e: (1,2,3)  => (6,5,3)
	 */ 
	public Vector changeVector(){
		Vector result = new Vector (this.size()); 
		for (int i = 0; i < this.size(); i ++){
			double sum = 0.0;
			for (int j = i; j < this.size(); j ++) {
				sum += this.get(j);
			}
			result.add(i, sum);
		}
		return result;
	}

	public void copy(Vector v){
		for (int i = 0; i < this.size(); i ++) {
			this.add(i, v.get(i));
		}
	}
	/*Methode de trie par selection
	 * Entr�e : le vecteur courant 
	 * Sortie : le vecteur courant tri�e dans l'ordre croissant.
	 */
	public void sort(){
		int  indice;
		for (int i = 0; i < this.size(); i ++) {
			indice = i;
			for (int j = i+1; j < this.size(); j ++) {
				if (this.get(j) < this.get(i)) { 
					if (this.get(indice) > this.get(j))  indice = j;
				} 	
			}
			echanger(this, i, indice);
		} 
	}

	/*Echange deux �l�ments d'un vecteur 
	 * Entr�e : le vecteur v, l'indice du premier �l�ment et celui du second �l�ments
	 * Sortie : Modifie le vecteur v.    
	 */
	public void echanger(Vector v, int a , int b){
		double tmp = v.get(a);
		v.set(a, v.get(b));
		v.set(b, tmp);
	}

	public void computeScale(int n, Random r){
		double tmp = Double.NEGATIVE_INFINITY;
		this.add(0, (double) r.nextInt(10));
		for (int i = 1; i < n; i ++) {
			tmp = r.nextInt(10) + this.get(i-1) + 1;
			this.add(i, tmp);
		}
	}

	public void computeScale(int n){
		computeScale(n, new Random());
	}

	public void arrondir(){
		for (int i = 0; i < this.size(); i ++) {
			this.set(i, (Math.floor(this.get(i) * 100.0)) / 100);
		}
	}
	//comparaison de vecteur au sens de Pareto
	/*Entr�e  : Un vecteur
	 *Sortie : vrai si le vecteur courant est prefer� au sens de Pareto au vecteur d'entr�e.
	 */
	public 	boolean compare( Vector q){
		Vector resultChangeV1 = this.changeVector();
		Vector resultChangeV2 = q.changeVector();
		int count = 0;
//		boolean result = false;
		if ( resultChangeV1.equals(resultChangeV2)) {
			return true;
		} else {
			for (int i = 0; i < this.size(); i ++) {
				if (resultChangeV1.get(i) >= resultChangeV2.get(i)) count++;
			}
			if (count == this.size()){
				return true;
			}
		}
		return false;
	}
	/*Compare deux vecteurs
	 * Entr�e : un vector 
	 * Sortie :  vrai si le vecteur d'entr�e est �gale au veteur courant, faux sinon.
	 */
	/*public boolean equals(Vector v){
		boolean result=false;
		int count=0;
		for (int i=0; i<this.size(); i++){

			if (Math.abs(this.get(i)-v.get(i)) <1E-5) count++;
		}
		if (count==this.size()) result=true;
		return result;
	}*/
}
